/**
 * 
 */

/*
*Released on 28th June 2008.
*Any violations can be reported at paritosh@wikiocean.net
*What is treated as violations can be found at www.wikiocean.net/ppl1-voilations*
******************************************************************************
* The contents of this file are subject to POOL Public License 1.0 and later.
* POOL Public License is based on Affero GPL v3 and additional conditions.
* ("License"); You may not use this file except in compliance with the License
* You may obtain a copy of the Affero GPL v3 License at http://www.gnu.org/licenses/agpl.html
* You may obtain a copy of the POOL Public License 1.0 or later at www.wikiocean.net/license/ppl.html
* Software distributed under POOL Public License 1.0 is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
* The Initial Developer of the Original Code is Paritosh Pungaliya (C) 2008. All Rights Reserved.
******************************************************************************
* Objective of the additional terms (license)
* 1) Is to extend the software freedom to freedom to work.
* 2) To ensure that knowledge is free from monopoly of agencies.
* 3) To avoid a situation where big corporate or investor can buy out free software groups and companies and then start milking the communities built around it.
* (this trend can be seen how the freedom is curtailed in companies that get Venture Capital funding.)
******************************************************************************
*/

package  database;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import logger.PoolLogger;

import utility.Input;

import dbmanager.DBManager;

/**
 * @author divyesh
 *
 */
public class RecordSearch 
{
	String query = null;
	ResultSet rs;
	String tablename = "property_details";
	Hashtable<Object, Object> condition;
	PoolLogger pl;
	
	public RecordSearch() {
		pl = (PoolLogger) PoolLogger.getLogger(this.getClass().getName());
	}
	
	/**
	 * queryBuilder() method will build a query as per the parameters passed to the method,
	 * @param tblName, name of table,
	 * @param condition, condition of query after where clause.
	 * if both parameters present then it will create proper query with table name and where clause, but   
	 * if condition is empty then it will take as a simple table name. 
	 * */	
	private String queryBuilder() 
	{		
	
		String hashCondition = "";
		
		if(tablename.length() != 0)
		{
			if(condition.isEmpty())
			{
				System.out.println(" Condition Value Is Not Present ");
				pl.info(" Condition Value Is Not Present ");
    			pl.debug(" Condition Value Is Not Present ");
    			pl.warn(" Condition Value Is Not Present ");
    			pl.fatal(" Condition Value Is Not Present ");
    			pl.error(" Condition Value Is Not Present ");
    			pl.trace(" Condition Value Is Not Present ");
				query = "SELECT * FROM " + tablename;
			}
			else
			{
				Enumeration<Object> hashKeys;
				hashKeys = condition.keys();
				
				while(hashKeys.hasMoreElements())
				{
					String columnmName = hashKeys.nextElement().toString();
					String columnValue = condition.get(columnmName).toString();
					if(columnValue.equalsIgnoreCase("null"))
							hashCondition = hashCondition + columnmName + " is " + columnValue + " AND ";
					else
						hashCondition = hashCondition + columnmName + " = '" + columnValue + "' AND ";
				}
				hashCondition = hashCondition.substring(0, hashCondition.length() - 4);
				query = "SELECT mid, pid, pv, vt, ref, fd, td FROM " + tablename + " where " + hashCondition;
			}			
		}
		else
		{
			System.out.println(" Table Name Does Not Exists. ");
			pl.info(" Table Name Does Not Exists. ");
			pl.debug(" Table Name Does Not Exists. ");
			pl.warn(" Table Name Does Not Exists. ");
			pl.fatal(" Table Name Does Not Exists. ");
			pl.error(" Table Name Does Not Exists. ");
			pl.trace(" Table Name Does Not Exists. ");
		}		
		return query;
	}
	
	/**
	 * It will returns result set of the supplied query string.
	 * @param query, which is the query string.
	 * @return Result Set of the query string.
	 * */
	public ResultSet getResultSet() 
	{		
		queryBuilder();
		rs = DBManager.getSelect(query);	
		return rs;		
	}
	
	/**
	 * getArrayFromResultSet() will build a string array from the resultset.
	 * @return String array, which is(are) the record(s) from the result set.   
	 * */
	public String[] getArrayFromResultSet() 
	{	
		getResultSet();
		try 
		{
			int i = 1;
			rs.next();
			int noOfCol = rs.getMetaData().getColumnCount() + 1;
			StringBuffer resultBuffer = new StringBuffer();
			rs.previous();
			while(rs.next())
			{
				String row ="" ;
				int j = 1;
	        	while(j != noOfCol)
	           	{	        		
	           		try 
	           		{
						String col = rs.getMetaData().getColumnName(j).toString();
						String value = rs.getString(col);
						row = row + value + Input.SEPARATOR; 
					}
	           		catch (Exception e) 
	           		{	
						row = row + "" + Input.SEPARATOR;
					}
					j++;
				}
	        	resultBuffer.append(row+Input.ENDSEPARATOR);
	        	i++;
			}	
			rs.close();
			if(resultBuffer.length()>0)
				return resultBuffer.toString().split(Input.ENDSEPARATOR);
			else
				return new String[0];
		} 
		catch (SQLException e) 
		{
			e.printStackTrace();
		}
		return null;		
	}
	
	/**
	 * getHashFromResultSet() will build a HashTable from the resultset.
	 * @return HashTable, which is(are) the record(s) from the result set.   
	 * */
	public Hashtable getHashFromResultSet()
	{
		Hashtable<Object,Object> recorHash = new Hashtable<Object,Object>();			    
		try 
		{
			int i = 1;
			rs.next();
			int noOfCol = rs.getMetaData().getColumnCount() + 1;
			rs.previous();
			while(rs.next())
			{
				int j = 1;
	        	while(j != noOfCol)
	           	{	        		
	           		try 
	           		{
						String key = rs.getMetaData().getColumnName(j).toString();
						String value = rs.getString(key);
						recorHash.put(key, value);
					} 
	           		catch (Exception e)  {}
					j++;
				}
	        	i++;
			}	
			rs.close();
        	return recorHash;
		} 
		catch (SQLException e) 
		{
			e.printStackTrace();
		}
		return recorHash;
	}
	
	/**
	 * getVectorFromResultSet() will build a Vector from the resultset.
	 * @return HashTable, which is(are) the record(s) from the result set.   
	 * */
	public Vector<Object> getVectorFromResultSet()
	{
		Vector<Object> recordVector = new Vector<Object>();
					    
		try 
		{
			getResultSet();
			int i = 1;
			rs.next();
			int noOfCol = rs.getMetaData().getColumnCount() + 1;
			rs.previous();
			while(rs.next())
			{
				Hashtable<Object,Object> recordHash = new Hashtable<Object,Object>();
				int j = 1;
	        	while(j != noOfCol)
	           	{	        		
	           		try 
	           		{
						String key = rs.getMetaData().getColumnName(j).toString();
						String value = rs.getString(key);
						recordHash.put(key, value);
					} 
	           		catch (Exception e)  {}
					j++;
				}
	        	recordVector.add(recordHash);
	        	i++;
			}	
			rs.close();
        	return recordVector;
		} 
		catch (SQLException e) 
		{
			e.printStackTrace();
		}
		return recordVector;
	}
	
	/**
	 * getColumnIndexDB() method will returns the index of the column from the database, 
	 * which match with specified column name.
	 * */
	public int getColumnIndexDB(String colName) 
	{
		int index = 0;
		ResultSet rs = DBManager.getSelect("SELECT * FROM " + tablename + " WHERE mid = '1'");
		try 
		{
			int i = 1;
			while(i!=rs.getMetaData().getColumnCount()+1)
           	{
           		String col = rs.getMetaData().getColumnName(i+1).toString();
           		if(colName.equalsIgnoreCase(col))
				{
					index = i - 1;
					return index;
				}
           		i++;
           	}
		} 
		catch (SQLException e) 
		{
			e.printStackTrace();
		}
		return index;		
	}
	
	public void setTablename(String tablename)
	{
		this.tablename = tablename;
	}
	
	public void setConditionMap(Hashtable<Object, Object> condition)
	{
		this.condition = new Hashtable<Object, Object>();
		this.condition.putAll(condition);
	}
	/**
	 * @param args
	 */
	public static void main(String[] args)	
	{
		Hashtable<Object,Object> conditionHash = new Hashtable<Object,Object>();
		conditionHash.put("mid", "9375");
		conditionHash.put("pid", "35");
		
		RecordSearch ps = new RecordSearch();
		ps.setTablename("property_details");
		System.out.println(" \n Column Index Is : " + ps.getColumnIndexDB("pid"));
		/*ps.setConditionMap(conditionHash);
		String query = ps.queryBuilder();
		ps.getResultSet();
		//ps.getArrayFromResultSet();
		//ps.getHashFromResultSet();
		Vector<Object> vec = ps.getVectorFromResultSet();
		//Hashtable<Object, Object> hash = ps.getHashFromResultSet();
		System.out.println("OutPut is: " + vec);
		*/
		/*for(int i=0;i<abc.length;i++)
			System.out.println(abc[i]+"\n");*/
		
	}
}
